// package com.liangtian.mdm.material.service.impl;
//
// import com.github.pagehelper.PageHelper;
// import com.github.pagehelper.PageInfo;
// import com.liangtian.mdm.base.utils.ShiroSessionUtils;
// import com.liangtian.mdm.material.common.model.ReturnMess;
// import com.liangtian.mdm.material.common.util.ExcelExportUtil;
// import com.liangtian.mdm.material.dao.WlDrDao;
// import com.liangtian.mdm.material.dao.WlwlUpdateDao;
// import com.liangtian.mdm.material.model.*;
// import com.liangtian.mdm.material.service.*;
// import com.liangtian.mdm.system.business.dao.SysBusinessDao;
// import com.liangtian.mdm.system.file.service.SysFileService;
// import com.liangtian.mdm.system.log.service.SysLogService;
// import com.liangtian.mdm.system.parameter.service.SysParameterService;
// import com.liangtian.mdm.system.thumbnail.dao.SysThumbnaiDao;
// import com.liangtian.mdm.system.user.model.SysUser;
// import com.liangtian.mdm.util.ConstantBean;
// import com.liangtian.mdm.util.ImageUtil;
// import com.liangtian.mdm.util.StringUtil;
// import org.apache.poi.hssf.usermodel.HSSFDateUtil;
// import org.apache.poi.ss.usermodel.*;
// import org.apache.poi.ss.util.NumberToTextConverter;
// import org.apache.poi.xssf.usermodel.XSSFCell;
// import org.apache.poi.xssf.usermodel.XSSFRow;
// import org.apache.poi.xssf.usermodel.XSSFSheet;
// import org.apache.poi.xssf.usermodel.XSSFWorkbook;
// import org.springframework.beans.factory.annotation.Autowired;
// import org.springframework.stereotype.Service;
//
// import javax.servlet.http.HttpServletRequest;
// import javax.servlet.http.HttpServletResponse;
// import java.io.File;
// import java.io.InputStream;
// import java.lang.reflect.Field;
// import java.lang.reflect.Method;
// import java.text.DateFormat;
// import java.text.SimpleDateFormat;
// import java.util.*;
// import java.util.regex.Matcher;
// import java.util.regex.Pattern;
//
// @Service
// public class WlDrServiceImpl implements WlDrService {
//
//     // 注入物料dao接口
//     @Autowired
//     private WlDrDao wlDrDao;
//     @Autowired
//     private WlLbmbtzlService wlLbmbtzlService;
//     @Autowired
//     private WorkFlowService workFlowService;
//     @Autowired
//     private WlwlService wlwlService;
//     @Autowired
//     private WlwlDisService wlwlDisService;
//     @Autowired
//     private WlwlUpdateService wlwlUpdateService;
//     @Autowired
//     private WlLbmbService wlLbmbService;
//     @Autowired
//     private WlLbService wlLbService;
//     @Autowired
//     private SysFileService sysFileService;
//     @Autowired
//     private SysBusinessDao sysBusinessDao;
//     @Autowired
//     private SysParameterService sysParameterService;
//     @Autowired
//     private WlwlFieldService wlwlFieldService;
//     @Autowired
//     private WlbmLbJldwService wlbmLbJldwService;
//     @Autowired
//     private SysThumbnaiDao sysThumbnaiDao;
//     @Autowired
//     private WlwlUpdateDao wlwlUpdateDao;
//     @Autowired
//     SysLogService sysLogServiceImpl;
//     // @Value("${ConstantBean.CURRENT_SESSION_USER}")
//     // private String ConstantBean.CURRENT_SESSION_USER;
//
//     @Override
//     public WlDr getWlDrByWym(String wym) {
//         return wlDrDao.getWlDrByWym(wym);
//     }
//
//     @Override
//     public List<WlDrTzl> getWlDrTzl(Map<String, Object> cond) {
//         return wlDrDao.getWlDrTzl(cond);
//     }
//
//     @Override
//     public void insertWlDr(WlDr wlDr) {
//         SysUser user = ShiroSessionUtils
//                 .getSessionSysUser(ConstantBean.CURRENT_SESSION_USER);
//         wlDr.setStatus("1");
//         wlDr.setState("0");
//         wlDr.setCreatorId(user.getUserId().toString());
//         wlDr.setCreatorAccount(user.getUserAccount());
//         wlDr.setCreatorName(user.getUserName());
//         wlDr.setCreateTime("");
//         // TODO sys_user表中没有所属单位信息
//         // wlDr.setGsdm(user.getUnitId());
//         // wlDr.setGsmc(user.getUnitName());
//         wlDrDao.insertWlDr(wlDr);
//         //addSysLog(wlDr, "101", "新增");
//
//     }
//
//     @Override
//     public int updateWlDr(Map<String, Object> cond) {
//         return wlDrDao.updateWlDr(cond);
//     }
//
//     @Override
//     public void updateWlDr(Map<String, Object> cond, String wlDrTzlStr,
//                            String wlDrLanStr, HttpServletRequest request) {
//         String wym = (String) cond.get("wym");
//         if (!StringUtils.isEmpty(wym)) {
//             SysUser user = ShiroSessionUtils
//                     .getSessionSysUser(ConstantBean.CURRENT_SESSION_USER);
//             cond.put("update_uid", user.getUserId());
//             cond.put("update_uname", user.getUserName());
//             cond.put("update_time", new Date());
//             this.updateWlDr(cond);
//             wlDrDao.deleteWlDrTzlByWlDrId(wym);
//             List<WlDrTzl> list = parseWlDrTzlStr(wym,
//                     (String) cond.get("lbbm"), wlDrTzlStr);
//             // 把参数手动封装在Map中
//             Map<String, List<WlDrTzl>> map = new HashMap<String, List<WlDrTzl>>();
//             map.put("wlDrTzllist", list);
//             wlDrDao.batchInsertWlDrTzl(map);
//
//             // 附件上传
// 			/*SysBusiness sysb = new SysBusiness();
// 			sysb.setBusTable("WL_WL");
// 			List<SysBusiness> bList = sysBusinessDao.queryBusByContion(sysb);// 查询业务类型
// 			String bus_id = bList.get(0).getBusId();// 业务类型
// */
//             Map<String, Object> Fcond = new HashMap<>();
//             Fcond.put("surveyType", "WL_WL");
//             Fcond.put("surveyName", "WL_WL");
//             Fcond.put("dataId", wym);
//             // Fcond.put("fileList",result_map.get("fileList"));
//             Fcond.put("operType", request.getParameter("operType"));
//             sysFileService.insertFile(request, Fcond);
//             // 删除已上传附件
//             String delFileIds = request.getParameter("delFileIds");
//             if (!StringUtils.isEmpty(delFileIds)) {
//                 List<String> idList = StringUtil.split(delFileIds, ",");
//                 Map<String, Object> file_cond = new HashMap<>();
//                 file_cond.put("ids", idList);
//                 List<SysFile> sFile = sysFileService.queryFileByCond(file_cond);
//                 sysFileService.delFileByPath(sFile);
//             }
//
//             //17-11-22 如果附件中有图片创建缩略图--jyh
//             //String realPath = request.getSession().getServletContext().getRealPath("/");//项目根目录
//             this.createThumbnailImage(wym, "WL_WL");
//             // TODO 写日志
//         }
//     }
//
//     @Override
//     public void deleteWlDrByIdS(List<String> ids) {
//         // TODO Auto-generated method stub
//
//     }
//
//     @Override
//     public int logicDeleteWlDrByIdS(Map<String, Object> cond) {
//         // 2016-09-28 条件已下在xml里
//         // 找出刚刚逻辑删除(不包含处在删除时限里)的物料，用于写操作日志
//         /*
//          * cond.put("complexcondition",
//          * "not exists(select 1 from wl_lcrz w where w.wl_dr_id=t.wym and t.state='6' and ceil(sysdate-w.logtime)<"
//          * +cond.get("limitdays")+
//          * " and w.submitcount=t.submitcount and w.actiontype='2')");
//          */
//         int count = wlDrDao.logicDeleteWlDrByIdS(cond);
//         // TODO 写日志
//         cond.put("status", "2");
//         List<WlDr> list = wlDrDao.queryWlDr(cond);
// 		 /*for(WlDr wlDr : list){
// 			 addSysLog(wlDr, "103", "逻辑删除");
// 		 }*/
//
//         return count;
//     }
//
//     @Override
//     public void saveWlDr(WlDr wlDr, String wlDrTzlStr, String wlDrLanStr,
//                          HttpServletRequest request) {
//         try {
//             this.insertWlDr(wlDr);
//             String wym = wlDr.getWym();
//             List<WlDrTzl> list = parseWlDrTzlStr(wym, wlDr.getLbbm(), wlDrTzlStr);
//             // 把参数手动封装在Map中
//             Map<String, List<WlDrTzl>> map = new HashMap<String, List<WlDrTzl>>();
//             map.put("wlDrTzllist", list);
//             wlDrDao.batchInsertWlDrTzl(map);
//
//             //万达需求，根据特征量说明生成橡胶专用编码
//             String systemCode = sysParameterService.getSysParamValue("systemCode", "MDM");// 获取系统参数systemCode，如果返回值为空则默认返回值为"MDM"
//             if ("WanDa".equals(systemCode)) {
//                 Map<String, Object> cond = new HashMap<>();
//                 cond.put("wym", wym);
//                 wlDrDao.generateWandaXjbm(cond);
//             }
//             // 附件上传
// 			/*SysBusiness sysb = new SysBusiness();
// 			sysb.setBusTable("WL_WL");
// 			List<SysBusiness> bList = sysBusinessDao.queryBusByContion(sysb);// 查询业务类型
// 			String bus_id = bList.get(0).getBusId();// 业务类型*/
//             Map<String, Object> Fcond = new HashMap<>();
//             Fcond.put("surveyType", "WL_WL");//2018-01-2-30 物料直接存业务类型 不存id
//             Fcond.put("surveyName", "WL_WL");
//             Fcond.put("dataId", wym);
//             // Fcond.put("fileList",result_map.get("fileList"));
//             Fcond.put("operType", request.getParameter("operType"));
//             Map<String, Object> FMap = sysFileService.insertFile(request, Fcond);
//             //17-11-22 如果附件中有图片创建缩略图--jyh
//             //String realPath = request.getSession().getServletContext().getRealPath("/");//项目根目录
//             this.createThumbnailImage(wym, "WL_WL");
//         } catch (Exception e) {
//             e.printStackTrace();
//         }
//     }
//
//     /**
//      * 生成缩略图
//      *
//      * @param files
//      */
//     private void createThumbnailImage(String dataId, String surveyType) {
// //		String filePath = sysParameterService.getSysParamValue("");
// //		String filePath = "thumbnail/wl/"+dataId+"/";
//         //--edit by wangyk at 180402:修改缩略图创建路径，改成和原始文件相同路径下。
//         //--好处：1.便于查看管理运维 2.缩略图路径不在项目相对路径下，避免部署不注意时，丢失原缩略图信息。
//         String filePath = sysParameterService.getSysParamValue("filePath", "C:/mdmFile");
//         //--定义相对路径，存储到后台表的时候存储的是该变量的内容，便于img标签读取
//         String filePathXdlj = new SimpleDateFormat("yyyyMM").format(new Date()) + File.separator
//                 + dataId + File.separator + "thumbnail" + File.separator;
//         filePath = filePath + File.separator
//                 + surveyType + File.separator
//                 + filePathXdlj;
//         //先将原来生成的缩略图删除
//         File f = new File(filePath);
//         if (f.exists()) {
//             //删除图片
//             deleteDir(f);
//             //删除图片数据
//             Map<String, Object> cond = new HashMap<>();
//             cond.put("dataId", dataId);
//             sysThumbnaiDao.deleteSysThumbnaiByCond(cond);
//         }
//         //查询出当前物料上传成功的附件
//         Map<String, Object> file_cond = new HashMap<>();
//         file_cond.put("dataId", dataId);
//         file_cond.put("surveyType", surveyType);
//         List<SysFile> files = sysFileService.queryFilesBySurvey(file_cond);
//
//         List<SysThumbnai> s_lst = new ArrayList<SysThumbnai>();//需要保存的缩略图数据
//         int i = 1;
//         for (SysFile sysFile : files) {
//             String fileType = sysFile.getFileName().substring(sysFile.getFileName().lastIndexOf("."));//文件格式
//             if (".jpg".equalsIgnoreCase(fileType) || ".png".equalsIgnoreCase(fileType)) {
//                 //创建缩略图
//                 File imgFile = new File(sysFile.getFilePath());
//                 int w = 200;
//                 int h = 150;
//                 String fileName = sysFile.getFileName();
//                 ImageUtil.thumbnailImage(imgFile, w, h, fileName, filePath, true);
//
//                 SysUser user = ShiroSessionUtils
//                         .getSessionSysUser(ConstantBean.CURRENT_SESSION_USER);
//                 SysThumbnai sysThumbnai = new SysThumbnai();//缩略图
//                 sysThumbnai.setDataId(dataId);
//                 sysThumbnai.setFileName(fileName);
//                 sysThumbnai.setFilePath(filePathXdlj + fileName);
//                 sysThumbnai.setCreatorId(user.getUserId() + "");
//                 sysThumbnai.setFileType(fileType);
//                 sysThumbnai.setSurveyType(surveyType);
//                 s_lst.add(sysThumbnai);
//                 i++;
//             }
//         }
//
//         //将缩略图信息保存
//         if (!StringUtils.isEmpty(s_lst)) {
//             for (SysThumbnai sysThumbnai : s_lst) {
//                 sysThumbnaiDao.insertSysThumbnai(sysThumbnai);
//             }
//         }
//     }
//
//     private static boolean deleteDir(File dir) {
//
//         if (dir.isDirectory()) {
//             String[] children = dir.list();
//             //递归删除目录中的子目录下
//             for (int i = 0; i < children.length; i++) {
//                 boolean success = deleteDir(new File(dir, children[i]));
//                 if (!success) {
//                     return false;
//                 }
//             }
//         }
//         // 目录此时为空，可以删除
//         return dir.delete();
//
//     }
//
//     public void importWlDrQc(WlDr wlDr, List<WlDrTzl> tzls) {
//         if (!StringUtils.isEmpty(tzls)) {
//             List<WlDrTzl> list = new ArrayList<WlDrTzl>();
//             for (WlDrTzl tzl : tzls) {
//                 String qz = StringUtils.trimToEmpty(tzl.getTzlz());
//                 if (!(qz.equals("") || qz.equals("空"))) {
//                     list.add(tzl);
//                 }
//             }
//             StringBuffer buffer1 = new StringBuffer();
//             StringBuffer buffer2 = new StringBuffer();
//             StringBuffer buffer3 = new StringBuffer();
//             for (int i = 0; i < list.size(); i++) {
//                 String tmp = "";
//                 String hengli = "";//恒力全描述
//                 WlDrTzl tzl = list.get(i);
//                 String jldwlms = wlLbmbtzlService.getWlLbmbtzlById(
//                         tzl.getWlLbmbtzlId()).getJldwlms();
//                 if ("1".equals(jldwlms)) { // 计量单位加入长描述
//                     tmp = tzl.getQzfh() + tzl.getTzlz() + tzl.getHzfh()
//                             + tzl.getJldw();
//                 } else {
//                     tmp = tzl.getQzfh() + tzl.getTzlz() + tzl.getHzfh();
//                 }
//                 buffer1.append(tmp);
//                 if (i != list.size() - 1)
//                     buffer1.append(StringUtils.trimToEmpty(tzl.getLjfh())
//                             .replace("空格", " ").replace("空", ""));
//                 //2017-11-28--add--jyh【中纺】 前后置符号可能存在空格，需要转换
//                 String qzfh = StringUtils.trimToEmpty(tzl.getQzfh()).replace("空格", " ");
//                 String hzfh = StringUtils.trimToEmpty(tzl.getHzfh()).replace("空格", " ");
//                 hengli = tzl.getTzlmc() + " " + qzfh + tzl.getTzlz() + hzfh + tzl.getJldw() + ";";
//                 buffer2.append(tmp);
//                 buffer3.append(hengli);
//             }
//             String jc2 = "";
//             //晋煤生成短描述跟原短描述始终一致
//             jc2 = wlDr.getJc();
// //			if (!StringUtils.isEmpty(wlDr.getJc())) {
// //				try {
// //					int jclen = getStringLength(wlDr.getJc());
// //					if (jclen > 40) {
// //						//--edit by wangyk at 180410 start:新凤鸣短描述jc2没有40的限制，且不自动截取,且默认等于长描述，跟导入短描述jc的长度没有关系
// //						String systemCode = SysParamUtil.getParameterValue("systemCode");
// //						//--edit by wangyk at 180622:
// //						//--新凤鸣又取消了短描述可以超过40的限制，现在和产品一致了......
// //						//--使用简单的处理方式，将IF分支的判断由XFM改成XXX，保留功能以后实施的哪个项目可以使用这种逻辑
// //						if("XXX".equals(systemCode))
// //							jc2 = buffer1.toString();//--参考wlDr.setQc2()处的逻辑。
// //						else
// //							jc2 = wlDr.getJc().trim().substring(0, 39)+"*";
// //						//--edit by wangyk at 180410 end
// //					} else {
// //						//--edit by wangyk at 180410 start:新凤鸣短描述jc2没有40的限制，且不自动截取,且默认等于长描述，跟导入短描述jc的长度没有关系
// //						String systemCode = SysParamUtil.getParameterValue("systemCode");
// //						//--edit by wangyk at 180622:
// //						//--新凤鸣又取消了短描述可以超过40的限制，现在和产品一致了......
// //						//--使用简单的处理方式，将IF分支的判断由XFM改成XXX，保留功能以后实施的哪个项目可以使用这种逻辑
// //						if("XXX".equals(systemCode))
// //							jc2 = buffer1.toString();//--参考wlDr.setQc2()处的逻辑。
// //						else
// //							jc2 = wlDr.getJc();
// //						//--edit by wangyk at 180410 end
// //					}
// //				} catch (Exception e) {
// //					e.printStackTrace();
// //				}
// //			}
//             wlDr.setQc2(buffer1.toString());
//             wlDr.setJc2(jc2);
//             wlDr.setQcNoLjfh(buffer2.toString());
//             wlDr.setField16(buffer3.toString().substring(0, buffer3.toString().length() - 1));
//         }
//     }
//
//     @SuppressWarnings({"unchecked", "rawtypes"})
//     @Override
//     public PageInfo queryWlDr(Map<String, Object> cond) {
//         PageInfo pageInfo = null;
//         try {
//             /*
//              * 参数
//              *
//              * @params参数详情 pageNum 总页数
//              *
//              * @params参数详情 length 每页显示条数
//              *
//              * @params参数详情 start 起始条数
//              *
//              * @params参数详情 draw 请求次数
//              *
//              * @return 分页条件下的
//              */
//             Object pNo = cond.get("pageNum");
//             int pageNum, pageSize;
//             // export
//             if (pNo != null && !"NaN".equals(pNo)) {
//                 pageNum = Integer.parseInt(pNo.toString());// 页码
//             } else {
//                 pageNum = 1;
//             }
//             // pageSize=0时不分页
//             pageSize = Integer.parseInt(cond.get("limit").toString());// 模型定义页面要显示数据条数
//             // 例如
//             // 10,20,50,100
//             PageHelper.startPage(pageNum, pageSize);// 开始分页标志（当前页，显示条数）
//
//             List<WlDr> wlDr_lst = wlDrDao.queryWlDr(cond);
//             pageInfo = new PageInfo(wlDr_lst);
//         } catch (Exception e) {
//             e.printStackTrace();
//         }
//         return pageInfo;
//     }
//
//     @Override
//     public List<WlDr> queryWlDrByCond(Map<String, Object> cond) {
//         return wlDrDao.queryWlDr(cond);
//     }
//
//     @SuppressWarnings({"unchecked", "rawtypes"})
//     @Override
//     public PageInfo queryWlDrApprove(Map<String, Object> cond) {
//         // TODO Auto-generated method stub
//         PageInfo pageInfo = null;
//         try {
//             /*
//              * 参数
//              *
//              * @params参数详情 pageNum 总页数
//              *
//              * @params参数详情 length 每页显示条数
//              *
//              * @params参数详情 start 起始条数
//              *
//              * @params参数详情 draw 请求次数
//              *
//              * @return 分页条件下的
//              */
//             Object pNo = cond.get("pageNum");
//             int pageNum, pageSize;
//             // export
//             if (pNo != null && !"NaN".equals(pNo)) {
//                 pageNum = Integer.parseInt(pNo.toString());// 页码
//             } else {
//                 pageNum = 1;
//             }
//             // pageSize=0时不分页
//             pageSize = Integer.parseInt(cond.get("limit").toString());// 模型定义页面要显示数据条数
//             // 例如
//             // 10,20,50,100
//             PageHelper.startPage(pageNum, pageSize);// 开始分页标志（当前页，显示条数）
//
//             List<WlDr> wlDr_lst = wlDrDao.queryWlDrApprove(cond);
//             pageInfo = new PageInfo(wlDr_lst);
//         } catch (Exception e) {
//             e.printStackTrace();
//         }
//         return pageInfo;
//     }
//
//     @Override
//     public int queryWlDrCount(Map<String, Object> cond) {
//         return wlDrDao.queryWlDrCount(cond);
//     }
//
//     @Override
//     public int queryWlDrApproveCount(Map<String, Object> cond) {
//         // TODO Auto-generated method stub
//         return 0;
//     }
//
//     @Override
//     public String checkoutWlDr(Map<String, Object> cond) {
//         wlDrDao.checkoutWlDr(cond);
//         String msg = (String) cond.get("msg");
//         return msg;
//     }
//
//     @Override
//     public ReturnMess submitWlDr(List<WlDr> wlDrs) {
//         // TODO Auto-generated method stub
//         return null;
//     }
//
//     @Override
//     public int submitWlDr(WlDr wlDr) {
//         // TODO Auto-generated method stub
//         return 0;
//     }
//
//     @SuppressWarnings("rawtypes")
//     @Override
//     public PageInfo queryApproveData(Map<String, Object> cond) {
//         // TODO Auto-generated method stub
//         return null;
//     }
//
//     @Override
//     public ReturnMess approveWlDr(String approveInfo) {
//         // TODO Auto-generated method stub
//         return null;
//     }
//
//     @Override
//     public String createWl(Map<String, String> cond) {
//         wlDrDao.createWl(cond);
//         // mybatis调用存储过程，自动将返回值写入map
//         String msg = cond.get("msg");
//         // 如果生成物料代码成功
//         if ("1".equals(msg)) {
//             Map<String, Object> wl_cond = new HashMap<>();
//             wl_cond.put("wl_dr_id", cond.get("wym"));
//             List<Wlwl> wl_list = wlwlService.queryWlwlByCond(wl_cond);
//             if (!StringUtils.isEmpty(wl_list)) {
//                 Wlwl wl = wl_list.get(0);
//                 String actiontype = "1";// 操作类型 1:新增，2:修改，3:启用，4:停用
//                 wlwlDisService.insertWlwlDis(wl, actiontype);// 分发
//             }
//         }
//         return msg;
//     }
//
//     @Override
//     public String autoCreateWl(WlDr wlDr) {
//         // TODO Auto-generated method stub
//         return null;
//     }
//
//     @Override
//     public List<WlwlLan> getQcSimilar(Map<String, Object> cond) {
//         // TODO Auto-generated method stub
//         return null;
//     }
//
//     @Override
//     public List<SysUser> getApproverLstByWlDrId(String wlDrId,
//                                                 String unitPermission) {
//         // TODO Auto-generated method stub
//         return null;
//     }
//
//     @SuppressWarnings({"resource", "unchecked"})
//     @Override
//     public Map<String, Object> importWlFromExcel(InputStream inputStream,
//                                                  String wlLbmbId) {
//         boolean bool = false;// 默认此次导入操作不成功
//         StringBuffer buffer = new StringBuffer();
//         if (!StringUtils.isEmpty(wlLbmbId)) {
//             try {
//                 WlLbmb mb = new WlLbmb();
//                 mb.setId(wlLbmbId);
//                 WlLbmb wlLbmb = wlLbmbService.getWlLbmbById(mb);// 物料类别模板
//                 WlLb wllb = new WlLb();
//                 wllb.setLbbm(wlLbmb.getLbbm());
//                 WlLb wlLb = wlLbService.getWlLbById(wllb);// 物料类别
//                 Workbook wb = new XSSFWorkbook(inputStream);
//                 Sheet sheet = wb.getSheetAt(0);
//                 String sheetName = sheet.getSheetName();
//                 boolean flag = false;
//                 if (!StringUtils.isEmpty(sheetName)) {
//                     String[] tmp = sheetName.split("_");
//                     if (tmp != null && tmp.length == 2
//                             && tmp[1].equals(wlLbmb.getId()))
//                         flag = true;
//                 }
//                 if (!flag)
//                     buffer.append("通过判断Sheet页的名称，当前所导文件与所选中的模板不匹配！\r\n");
//                 // 获取有记录的行数--最后有数据的行是第n行，前面有m行是空行没数据，则返回n-m；
//                 int rownum_yx = sheet.getPhysicalNumberOfRows();
//                 // System.out.println("有效数据行数："+rownum_yx);
//                 if (rownum_yx <= 2) {
//                     buffer.append("物料数据为空或未遵守模板格式填写物料数据！\r\n");
//                 } else {
//                     // 物料一次最多允许导入条数
//                     int wlImportLimit = Integer.parseInt(sysParameterService
//                             .getSysParamValue("wlImportLimit", "5000"));
//                     if (rownum_yx > wlImportLimit + 2) {
//                         flag = false;
//                         buffer.append("一次性导入物料数据请不要超过" + wlImportLimit
//                                 + "条！\r\n");
//                     }
//                     int rownum = sheet.getLastRowNum();// 当前sheet中有效的最后一行
//                     for (int d = 2; d <= rownum; d++) {
//                         String errorRowInfo = "第" + (d + 1) + "行";
//                         Row row = sheet.getRow(d);
//                         // 没有数据的行
//                         if (row == null || ExcelUtil.isRowEmpty(row))
//                             continue;
//                         if (row.getPhysicalNumberOfCells() > 0) {
//                             if (StringUtils.isEmpty(getCellVal(row, 1))) {
//                                 flag = false;
//                                 buffer.append(errorRowInfo + "短描述未填！\r\n");
//                                 // break;
//                             }
//                             if (!StringUtils.isEmpty(getCellVal(row, 1))) {
//                                 int sl = getStringLength(getCellVal(row, 1));
//                                 if (sl > 40) {
//                                     //--edit by wangyk at 180410 start:新凤鸣短描述没有40的限制
//                                     String systemCode = SysParamUtil.getParameterValue("systemCode");
//                                     //--edit by wangyk at 180622:
//                                     //--新凤鸣又取消了短描述可以超过40的限制，现在和产品一致了......
//                                     //--使用简单的处理方式，将IF分支的判断由XFM改成XXX，保留功能以后实施的哪个项目可以使用这种逻辑
//                                     if (!"XXX".equals(systemCode)) {
//                                         flag = false;
//                                         buffer.append(errorRowInfo + "短描述长度不可超过40字符！\r\n");
//                                     }
//                                     //--edit by wangyk at 180410 end
//                                 }
//                             }
//                         }
//                     }
//                     if (flag) {
//                         //模板特征量
//                         List<WlLbmbtzl> tzls = wlLbmbtzlService.getWlLbmbtzlListSimple(wlLbmbId);
//                         //2017-07-18取出模板特征量的对应的符号及取值（往数据库插入符号ID用）
//                         List<WlLbmbtzlDto> tzlDtoList = wlLbmbtzlService.getWlLbmbtzlDtoListForApplyPage(wlLbmbId, true);
//                         //转换数据
//                         Map<String, Map<String, String>> tzlDtoMap = tzlDtoListToMap(tzlDtoList);//转一下格式  方便下面取用
//                         if (StringUtils.isEmpty(tzls)) {
//                             buffer.append("物料申请模板未找到特征量数据！\r\n");
//                         } else if (StringUtils.isEmpty(buffer.toString())) {
//                             // 如果前面的校验都通过
//                             // List<WlDr> wlDrList = new ArrayList<WlDr>();
//                             // List<WlDrTzl> wlDrTzlList = new
//                             // ArrayList<WlDrTzl>();
//                             // int colNum =
//                             // sheet.getRow(1).getPhysicalNumberOfCells();//获取有效列数
//                             //2017-07-18新增
//                             //类别计量单位
//                             Map<String, Object> lbjldwcx = new HashMap<>();
//                             lbjldwcx.put("lbbm", wlLb.getLbbm());
//                             List<WlbmLbJldw> jldwList = wlbmLbJldwService.getWlbmLbJldwByCond2(lbjldwcx);
//                             Map<String, String> jldwMap = new HashMap<String, String>();
//                             for (WlbmLbJldw wlbmLbJldw : jldwList)
//                                 jldwMap.put(wlbmLbJldw.getMc(), wlbmLbJldw.getLbjldw_id());
//                             //类别计量单位 -----END-----
//
//                             List<Map<String, Object>> wl_list = new ArrayList<Map<String, Object>>();
//                             Map<String, String> qc_map = new HashMap<String, String>();
//                             int count = 0;// 导入成功的总行数
//                             for (int rindex = 2; rindex <= rownum; rindex++) {
//                                 Row row = sheet.getRow(rindex);
//                                 if (row == null || ExcelUtil.isRowEmpty(row))
//                                     continue;
//                                 // System.out.println(("第"+rindex+1)+"行有效单元格数："+row.getPhysicalNumberOfCells());
//                                 if (row.getPhysicalNumberOfCells() > 0) {
//                                     WlDr dr = new WlDr();
//                                     dr.setWlLbmbId(wlLbmbId);
//                                     dr.setLbbm(wlLb.getLbbm());
//                                     dr.setLbmc(wlLb.getLbmc());
//                                     dr.setErpjldw(wlLb.getJldw());
//                                     dr.setQc(getCellVal(row, 0));
//                                     dr.setJc(getCellVal(row, 1));
//
//                                     List<WlDrTzl> tzlList = new ArrayList<WlDrTzl>();
//                                     int j = 2;
//                                     int f = 0;
//                                     for (; j < 5*tzls.size() + 2; ) {
//                                         WlLbmbtzl tzl = tzls.get(f);
//                                         f++;
//                                         String tzlId = tzl.getId();
//                                         Map<String, String> qzfh_Map = tzlDtoMap.get(tzlId + "_qzfh");//特征量前置符号map
//                                         Map<String, String> tzlz_Map = tzlDtoMap.get(tzlId + "_tzlz");//特征量取值map
//                                         Map<String, String> hzfh_Map = tzlDtoMap.get(tzlId + "_hzfh");//特征量后置符号map
//                                         Map<String, String> ljfh_Map = tzlDtoMap.get(tzlId + "_ljfh");//特征量连接符号map
//                                         Map<String, String> jldw_Map = tzlDtoMap.get(tzlId + "_jldw");//特征量计量单位map
//                                         String qzfh = getCellVal(row, j++);//前置符号
//                                         String tzlz = getCellVal(row, j++);//特征量值
//                                         String hzfh = getCellVal(row, j++);//后置符号
//                                         String jldw = getCellVal(row, j++);//计量单位
//                                         String ljfh = getCellVal(row, j++);//连接符号
//                                         WlDrTzl tzlDr = new WlDrTzl();
//                                         tzlDr.setWlLbmbtzlId(tzlId);
//                                         tzlDr.setXh(tzl.getXh());
//                                         tzlDr.setTzlmc(tzl.getTzlmc());
//                                         tzlDr.setLbbm(wlLb.getLbbm());
//                                         tzlDr.setStatus("1");
//                                         if (!StringUtils.isEmpty((qzfh_Map)))
//                                             tzlDr.setQzfhId(qzfh_Map.get(qzfh));
//                                         tzlDr.setQzfh(qzfh);
//                                         if (!StringUtils.isEmpty((tzlz_Map)))
//                                             tzlDr.setTzlzId(tzlz_Map.get(tzlz));
//                                         tzlDr.setTzlz(tzlz);
//                                         if (!StringUtils.isEmpty((hzfh_Map)))
//                                             tzlDr.setHzfhId(hzfh_Map.get(hzfh));
//                                         tzlDr.setHzfh(hzfh);
//                                         if (!StringUtils.isEmpty((jldw_Map)))
//                                             tzlDr.setJldwId(jldw_Map.get(jldw));
//                                         tzlDr.setJldw(jldw);
//                                         if (!StringUtils.isEmpty((ljfh_Map)))
//                                             tzlDr.setLjfhId(ljfh_Map.get(ljfh));
//                                         tzlDr.setLjfh(ljfh);
//                                         tzlList.add(tzlDr);
//                                     }
//                                     String jldw = getCellVal(row, j++);
//                                     dr.setJldwId(jldwMap.get(jldw));
//                                     dr.setJldw(jldw);
//                                     // if(StringUtils.trimToEmpty(wlLb.getWzcpbz()).equals("2")){
//                                     // dr.setScdm(getCellVal(row, j++));
//                                     // dr.setSccpmc(getCellVal(row, j++));
//                                     // dr.setDivision(getCellVal(row, j++));
//                                     // }
//                                     /*
//                                      * dr.setHs(getCellVal(row, j++));
//                                      * dr.setGjtjjhycpm(getCellVal(row, j++));
//                                      * dr.setTm(getCellVal(row, j++));
//                                      * dr.setSm(getCellVal(row, j++));
//                                      */
//                                     // ----START----
//                                     // jyh -- 2017-07-08
//                                     // 以下为用户自己配置的表单中的业务字段导入逻辑
//                                     // 通过表头判断该字段是否 '备注'字段（备注字段为excel模板中的最后一列）
//                                     Row r = sheet.getRow(1);// 表头
//                                     //可配置物料字段
//                                     Map<String, Object> field_cond = new HashMap<>();
//                                     field_cond.put("sfbdxs", "1");
//                                     List<WlwlField> fieldList = wlwlFieldService.queryWlwlFieldByCond(field_cond);
//                                     Map<String, String> fieldMap = new HashMap<String, String>();
//                                     for (WlwlField wlwlField : fieldList)
//                                         fieldMap.put(wlwlField.getField(), wlwlField.getFieldName());
//                                     // 可配置业务字段
//                                     for (int i = 0; i < fieldList.size() + 1; i++) {
//                                         String field = getCellVal(r, j);// 表头字段
//                                         // 如果当前列对应的表头信息为'备注'表示可配置业务字段已结束
//                                         if ("备注".equals(field)) {
//                                             dr.setRemark(getCellVal(row, j));
//                                             break;
//                                         } else {
//                                             String value = getCellVal(row, j);// 对应excel列中填的值
//                                             setField(field, value, dr, fieldMap);
//
//                                             //配置字段必填项校验
//                                             if ("1".equals(fieldList.get(i).getSfbt())) {
//                                                 if (StringUtils.isEmpty(value)) {
//                                                     flag = false;
//                                                     buffer.append("第" + (rindex + 1) + "行" + fieldList.get(i).getFieldName() + "未填！\r\n");
//                                                 }
//                                             }
//                                         }
//                                         j++;
//                                     }
//                                     // ----END----
//
//                                     this.importWlDrQc(dr, tzlList);// 拼物料长描述等信息
//
//                                     String qc2 = dr.getQc2();
//                                     // 校验excel中填写的长描述和生成的长描述是否一致(如果填值需要校验，实际是为了校验短描述（手填）是否正确)
//                                     String excel_qc = getCellVal(row, 0);
// //									if (!StringUtils.isEmpty(excel_qc) && !qc2.equals(excel_qc)) {
// 									/*if (StringUtils.isEmpty(excel_qc)) {
// 										//只是校验excel中数据的正确性
// 										flag = false;
// 										buffer.append("第" + (rindex+1) + "行填写的物料长描述与生成的长描述不一致！\r\n");
// 									}else {*/
//                                     int sl = getStringLength(qc2);
//                                     if (sl > 400) {
//                                         flag = false;
//                                         buffer.append("第" + (rindex + 1) + "行生成物料长描述长度不可超过400字符！\r\n");
//                                     } else {
//                                         qc_map.put(qc2, rindex + "");
//                                         Map<String, Object> wl_map = new HashMap<>();
//                                         wl_map.put("wldr", dr);
//                                         wl_map.put("tzlList", tzlList);
//                                         wl_list.add(wl_map);
//                                         count++;
//                                     }
//
// //									}
//
//                                     /*
//                                      * //校验是否存在重复数据（特征量信息）
//                                      * if(StringUtils.isEmpty(qc_map.get(qc2))){
//                                      * qc_map.put(qc2, rindex+""); Map<String,
//                                      * Object> wl_map = new HashMap<String,
//                                      * Object>(); wl_map.put("wldr", dr);
//                                      * wl_map.put("tzlList", tzlList);
//                                      * wl_list.add(wl_map); count++; }else{ flag
//                                      * = false;
//                                      * buffer.append("第"+rindex+"行特征量数据与第"
//                                      * +qc_map.get(qc2)+"行重复！\r\n"); }
//                                      */
//                                 }
//                             }
//                             if (flag) {
//                                 for (int w = 0; w < wl_list.size(); w++) {
//                                     insertImportWldr(
//                                             (WlDr) wl_list.get(w).get("wldr"),
//                                             (List<WlDrTzl>) wl_list.get(w).get(
//                                                     "tzlList"));
//                                 }
//                                 bool = true;
//                                 buffer.append("成功导入" + count + "条物料数据！");
//                             }
//                         }
//                     }
//                 }
//                 inputStream.close();
//             } catch (Exception e) {
//                 e.printStackTrace();
//                 buffer.append("校验excel数据异常或插入数据异常，请联系管理员\r\n");
//             } finally {
//                 try {
//                     if (inputStream != null)
//                         inputStream.close();
//                 } catch (Exception e) {
//                     e.printStackTrace();
//                     buffer.append("文件读取异常，请联系管理员\r\n");
//                 }
//             }
//         } else {
//             buffer.append("未指定有效申请模板！\r\n");
//         }
//         Map<String, Object> map = new HashMap<>();
//         map.put("success", bool);
//         map.put("info", buffer.toString());
//         return map;
//     }
//
// //	@SuppressWarnings({ "resource", "unchecked" })
// //	@Override
// //	public Map<String, Object> importWlFromExcel(InputStream inputStream,
// //			String wlLbmbId) {
// //		boolean bool = false;// 默认此次导入操作不成功
// //		StringBuffer buffer = new StringBuffer();
// //		if (!StringUtils.isEmpty(wlLbmbId)) {
// //			try {
// //				WlLbmb mb = new WlLbmb();
// //				mb.setId(wlLbmbId);
// //				WlLbmb wlLbmb = wlLbmbService.getWlLbmbById(mb);// 物料类别模板
// //				WlLb wllb = new WlLb();
// //				wllb.setLbbm(wlLbmb.getLbbm());
// //				WlLb wlLb = wlLbService.getWlLbById(wllb);// 物料类别
// //				Workbook wb = new XSSFWorkbook(inputStream);
// //				Sheet sheet = wb.getSheetAt(0);
// //				String sheetName = sheet.getSheetName();
// //				boolean flag = false;
// //				if (!StringUtils.isEmpty(sheetName)) {
// //					String[] tmp = sheetName.split("_");
// //					if (tmp != null && tmp.length == 2
// //							&& tmp[1].equals(wlLbmb.getId()))
// //						flag = true;
// //				}
// //				if (!flag)
// //					buffer.append("通过判断Sheet页的名称，当前所导文件与所选中的模板不匹配！\r\n");
// //				// 获取有记录的行数--最后有数据的行是第n行，前面有m行是空行没数据，则返回n-m；
// //				int rownum_yx = sheet.getPhysicalNumberOfRows();
// //				// System.out.println("有效数据行数："+rownum_yx);
// //				if (rownum_yx <= 2) {
// //					buffer.append("物料数据为空或未遵守模板格式填写物料数据！\r\n");
// //				} else {
// //					// 物料一次最多允许导入条数
// //					int wlImportLimit = Integer.parseInt(sysParameterService
// //							.getSysParamValue("wlImportLimit", "5000"));
// //					if (rownum_yx > wlImportLimit + 2) {
// //						flag = false;
// //						buffer.append("一次性导入物料数据请不要超过" + wlImportLimit
// //								+ "条！\r\n");
// //					}
// //					int rownum = sheet.getLastRowNum();// 当前sheet中有效的最后一行
// //					for (int d = 2; d <= rownum; d++) {
// //						String errorRowInfo = "第" + (d + 1) + "行";
// //						Row row = sheet.getRow(d);
// //						// 没有数据的行
// //						if (row == null || ExcelUtil.isRowEmpty(row))
// //							continue;
// //						if (row.getPhysicalNumberOfCells() > 0) {
// //							if (StringUtils.isEmpty(getCellVal(row, 1))) {
// //								flag = false;
// //								buffer.append(errorRowInfo + "短描述未填！\r\n");
// //								// break;
// //							}
// //							if (!StringUtils.isEmpty(getCellVal(row, 1))) {
// //								int sl = getStringLength(getCellVal(row, 1));
// //								if(sl>40){
// //									flag = false;
// //									buffer.append(errorRowInfo + "短描述长度不可超过40字符！\r\n");
// //								}
// //							}
// //						}
// //					}
// //					if (flag) {
// //						//模板特征量
// //						List<WlLbmbtzl> tzls = wlLbmbtzlService.getWlLbmbtzlListSimple(wlLbmbId);
// //						//2017-07-18取出模板特征量的对应的符号及取值（往数据库插入符号ID用）
// //						List<WlLbmbtzlDto> tzlDtoList = wlLbmbtzlService.getWlLbmbtzlDtoListForApplyPage(wlLbmbId);
// //						//转换数据
// //						Map<String, Map<String, String>> tzlDtoMap = tzlDtoListToMap(tzlDtoList);//转一下格式  方便下面取用
// //						if (StringUtils.isEmpty(tzls)) {
// //							buffer.append("物料申请模板未找到特征量数据！\r\n");
// //						} else if (StringUtils.isEmpty(buffer.toString())) {
// //							// 如果前面的校验都通过
// //							// List<WlDr> wlDrList = new ArrayList<WlDr>();
// //							// List<WlDrTzl> wlDrTzlList = new
// //							// ArrayList<WlDrTzl>();
// //							// int colNum =
// //							// sheet.getRow(1).getPhysicalNumberOfCells();//获取有效列数
// //							//2017-07-18新增
// //							//类别计量单位
// //							Map<String, Object> lbjldwcx = new HashMap<>();
// //							lbjldwcx.put("lbbm", wlLb.getLbbm());
// //							List<WlbmLbJldw> jldwList = wlbmLbJldwService.getWlbmLbJldwByCond2(lbjldwcx);
// //							Map<String, String> jldwMap = new HashMap<String, String>();
// //							for (WlbmLbJldw wlbmLbJldw : jldwList)
// //								jldwMap.put(wlbmLbJldw.getMc(), wlbmLbJldw.getLbjldw_id());
// //							//类别计量单位 -----END-----
// //
// //							List<Map<String, Object>> wl_list = new ArrayList<Map<String, Object>>();
// //							Map<String, String> qc_map = new HashMap<String, String>();
// //							int count = 0;// 导入成功的总行数
// //							for (int rindex = 2; rindex <= rownum; rindex++) {
// //								Row row = sheet.getRow(rindex);
// //								if (row == null || ExcelUtil.isRowEmpty(row))
// //									continue;
// //								// System.out.println(("第"+rindex+1)+"行有效单元格数："+row.getPhysicalNumberOfCells());
// //								if (row.getPhysicalNumberOfCells() > 0) {
// //									WlDr dr = new WlDr();
// //									dr.setWlLbmbId(wlLbmbId);
// //									dr.setLbbm(wlLb.getLbbm());
// //									dr.setLbmc(wlLb.getLbmc());
// //									dr.setErpjldw(wlLb.getJldw());
// //									dr.setQc(getCellVal(row, 0));
// //									dr.setJc(getCellVal(row, 1));
// //
// //									List<WlDrTzl> tzlList = new ArrayList<WlDrTzl>();
// //									int j = 2;
// //									int f = 0;
// //									for (; j < 5 * tzls.size() + 2;) {
// //										WlLbmbtzl tzl = tzls.get(f);
// //										f++;
// //										String tzlId = tzl.getId();
// //										Map<String, String> qzfh_Map = tzlDtoMap.get(tzlId+"_qzfh");//特征量前置符号map
// ////										Map<String, String> tzlz_Map = tzlDtoMap.get(tzlId+"_tzlz");//特征量取值map
// //										Map<String, String> hzfh_Map = tzlDtoMap.get(tzlId+"_hzfh");//特征量后置符号map
// //										Map<String, String> ljfh_Map = tzlDtoMap.get(tzlId+"_ljfh");//特征量连接符号map
// //										Map<String, String> jldw_Map = tzlDtoMap.get(tzlId+"_jldw");//特征量计量单位map
// //										String qzfh = getCellVal(row, j++);//前置符号
// //										String tzlz = getCellVal(row, j++);//特征量值
// //										String hzfh = getCellVal(row, j++);//后置符号
// //										String jldw = getCellVal(row, j++);//计量单位
// //										String ljfh = getCellVal(row, j++);//连接符号
// //
// //										WlDrTzl tzlDr = new WlDrTzl();
// //										tzlDr.setWlLbmbtzlId(tzlId);
// //										tzlDr.setXh(tzl.getXh());
// //										tzlDr.setTzlmc(tzl.getTzlmc());
// //										tzlDr.setLbbm(wlLb.getLbbm());
// //										tzlDr.setStatus("1");
// //										if("1".equals(tzl.getQzfhsfkk())){
// //											if (!StringUtils.isEmpty(qzfh_Map.get(qzfh))) {
// //												tzlDr.setQzfhId(qzfh_Map.get(qzfh));
// //												tzlDr.setQzfh(qzfh);
// //											} else {
// //												flag = false;
// //												buffer.append("特征量："+tzl.getTzlmc()+"的前置符号:"+qzfh+"不在取值附表！\r\n");
// //											}
// //										} else {
// //											if(!StringUtils.isEmpty(qzfh)){
// //												flag = false;
// //												buffer.append("特征量："+tzl.getTzlmc()+"的前置符号:"+qzfh+"不在取值附表！\r\n");
// //											} else {
// //												tzlDr.setQzfh("");
// //											}
// //										}
// //
// //										tzlDr.setTzlz(tzlz);
// //										if("1".equals(tzl.getHzfhsfkk())){
// //											if (!StringUtils.isEmpty(hzfh_Map.get(hzfh))) {
// //												tzlDr.setHzfhId(hzfh_Map.get(hzfh));
// //												tzlDr.setHzfh(hzfh);
// //											} else {
// //												flag = false;
// //												buffer.append("特征量："+tzl.getTzlmc()+"的后置符号:"+hzfh+"不在取值附表！\r\n");
// //											}
// //										} else {
// //											if(!StringUtils.isEmpty(hzfh)){
// //												flag = false;
// //												buffer.append("特征量："+tzl.getTzlmc()+"的后置符号:"+hzfh+"不在取值附表！\r\n");
// //											} else {
// //												tzlDr.setHzfh("");
// //											}
// //										}
// //
// //										if(!StringUtils.isEmpty((jldw_Map)))
// //											tzlDr.setJldwId(jldw_Map.get(jldw));
// //										tzlDr.setJldw(jldw);
// //
// //										if(!StringUtils.isEmpty((ljfh_Map)))
// //											tzlDr.setLjfhId(ljfh_Map.get(ljfh));
// //										tzlDr.setLjfh(ljfh);
// //
// //										/*if(!StringUtils.isEmpty((jldw_Map))){
// //											if (!StringUtils.isEmpty(jldw_Map.get(jldw))) {
// //												tzlDr.setJldwId(jldw_Map.get(jldw));
// //												tzlDr.setJldw(jldw);
// //											} else {
// //												flag = false;
// //												buffer.append("特征量："+tzl.getTzlmc()+"的计量单位:"+jldw+"不在取值附表！\r\n");
// //											}
// //										} else {
// //											if(!StringUtils.isEmpty(jldw)){
// //												flag = false;
// //												buffer.append("特征量："+tzl.getTzlmc()+"的计量单位:"+jldw+"不在取值附表！\r\n");
// //											} else {
// //												tzlDr.setJldw("");
// //											}
// //										}*/
// //
// //										/*if(!StringUtils.isEmpty((ljfh_Map))){
// //											if (!StringUtils.isEmpty(ljfh_Map.get(ljfh))) {
// //												tzlDr.setLjfhId(ljfh_Map.get(ljfh));
// //												tzlDr.setLjfh(ljfh);
// //											} else {
// //												flag = false;
// //												buffer.append("特征量："+tzl.getTzlmc()+"的连接符号:"+ljfh+"不在取值附表！\r\n");
// //											}
// //										} else {
// //											if(!StringUtils.isEmpty(ljfh)){
// //												flag = false;
// //												buffer.append("特征量："+tzl.getTzlmc()+"的连接符号:"+ljfh+"不在取值附表！\r\n");
// //											} else {
// //												tzlDr.setLjfh("");
// //											}
// //										}*/
// //
// //										tzlList.add(tzlDr);
// //									}
// //									String jldw = getCellVal(row, j++);
// //									dr.setJldwId(jldwMap.get(jldw));
// //									dr.setJldw(jldw);
// //									// if(StringUtils.trimToEmpty(wlLb.getWzcpbz()).equals("2")){
// //									// dr.setScdm(getCellVal(row, j++));
// //									// dr.setSccpmc(getCellVal(row, j++));
// //									// dr.setDivision(getCellVal(row, j++));
// //									// }
// //									/*
// //									 * dr.setHs(getCellVal(row, j++));
// //									 * dr.setGjtjjhycpm(getCellVal(row, j++));
// //									 * dr.setTm(getCellVal(row, j++));
// //									 * dr.setSm(getCellVal(row, j++));
// //									 */
// //									// ----START----
// //									// jyh -- 2017-07-08
// //									// 以下为用户自己配置的表单中的业务字段导入逻辑
// //									// 通过表头判断该字段是否 '备注'字段（备注字段为excel模板中的最后一列）
// //									Row r = sheet.getRow(1);// 表头
// //									//可配置物料字段
// //									Map<String, Object> field_cond = new HashMap<>();
// //									field_cond.put("sfbdxs", "1");
// //									List<WlwlField> fieldList = wlwlFieldService.queryWlwlFieldByCond(field_cond);
// //									Map<String, String> fieldMap = new HashMap<String, String>();
// //									for (WlwlField wlwlField : fieldList)
// //										fieldMap.put(wlwlField.getField(), wlwlField.getFieldName());
// //									// 可配置业务字段
// //									for (int i = 0; i < fieldList.size()+1; i++) {
// //										String field = getCellVal(r, j);// 表头字段
// //										// 如果当前列对应的表头信息为'备注'表示可配置业务字段已结束
// //										if ("备注".equals(field)) {
// //											dr.setRemark(getCellVal(row, j));
// //											break;
// //										} else {
// //											String value = getCellVal(row, j);// 对应excel列中填的值
// //											setField(field, value, dr, fieldMap);
// //										}
// //										j++;
// //									}
// //									// ----END----
// //
// //									this.importWlDrQc(dr, tzlList);// 拼物料长描述等信息
// //
// //									String qc2 = dr.getQc2();
// //									// 校验excel中填写的长描述和生成的长描述是否一致(如果填值需要校验，实际是为了校验短描述（手填）是否正确)
// //									String excel_qc = getCellVal(row, 0);
// //									if (!StringUtils.isEmpty(excel_qc) && !qc2.equals(excel_qc)) {
// //										//只是校验excel中数据的正确性
// //										flag = false;
// //										buffer.append("第" + (rindex+1) + "行填写的物料长描述与生成的长描述不一致！\r\n");
// //									}else {
// //										int sl = getStringLength(qc2);
// //										if(sl>400){
// //											flag = false;
// //											buffer.append("第" + (rindex+1) + "行生成物料长描述长度不可超过400字符！\r\n");
// //										}else{
// //											qc_map.put(qc2, rindex + "");
// //											Map<String, Object> wl_map = new HashMap<>();
// //											wl_map.put("wldr", dr);
// //											wl_map.put("tzlList", tzlList);
// //											wl_list.add(wl_map);
// //											count++;
// //										}
// //
// //									}
// //
// //									/*
// //									 * //校验是否存在重复数据（特征量信息）
// //									 * if(StringUtils.isEmpty(qc_map.get(qc2))){
// //									 * qc_map.put(qc2, rindex+""); Map<String,
// //									 * Object> wl_map = new HashMap<String,
// //									 * Object>(); wl_map.put("wldr", dr);
// //									 * wl_map.put("tzlList", tzlList);
// //									 * wl_list.add(wl_map); count++; }else{ flag
// //									 * = false;
// //									 * buffer.append("第"+rindex+"行特征量数据与第"
// //									 * +qc_map.get(qc2)+"行重复！\r\n"); }
// //									 */
// //								}
// //							}
// //							if (flag) {
// //								for (int w = 0; w < wl_list.size(); w++) {
// //									insertImportWldr(
// //											(WlDr) wl_list.get(w).get("wldr"),
// //											(List<WlDrTzl>) wl_list.get(w).get(
// //													"tzlList"));
// //								}
// //								bool = true;
// //								buffer.append("成功导入" + count + "条物料数据！");
// //							}
// //						}
// //					}
// //				}
// //				inputStream.close();
// //			} catch (Exception e) {
// //				e.printStackTrace();
// //				buffer.append("校验excel数据异常或插入数据异常，请联系管理员\r\n");
// //			} finally {
// //				try {
// //					if (inputStream != null)
// //						inputStream.close();
// //				} catch (Exception e) {
// //					e.printStackTrace();
// //					buffer.append("文件读取异常，请联系管理员\r\n");
// //				}
// //			}
// //		} else {
// //			buffer.append("未指定有效申请模板！\r\n");
// //		}
// //		Map<String, Object> map = new HashMap<>();
// //		map.put("success", bool);
// //		map.put("info", buffer.toString());
// //		return map;
// //	}
//
//     @SuppressWarnings("unchecked")
//     private Map<String, Map<String, String>> tzlDtoListToMap(List<WlLbmbtzlDto> tzlDtoList) {
//         //格式  key:tzlId+_+fhType,value:符号map
//         Map<String, Map<String, String>> result = new HashMap<String, Map<String, String>>();
//         for (WlLbmbtzlDto dto : tzlDtoList) {
//
//             //fhMap格式：key:fhname,value:fhwym
//             if (!StringUtils.isEmpty(dto.getQzfhList())) {
//                 Map<String, String> qzfh_map = fhListToMap(dto.getQzfhList());
//                 result.put(dto.getId() + "_qzfh", qzfh_map);
//             }
//             if (!StringUtils.isEmpty(dto.getTzlzList())) {
//                 Map<String, String> tzlz_map = tzlzListToMap(dto.getTzlzList());
//                 result.put(dto.getId() + "_tzlz", tzlz_map);
//             }
//             if (!StringUtils.isEmpty(dto.getHzfhList())) {
//                 Map<String, String> hzfh_map = fhListToMap(dto.getHzfhList());
//                 result.put(dto.getId() + "_hzfh", hzfh_map);
//             }
//             if (!StringUtils.isEmpty(dto.getLjfhList())) {
//                 Map<String, String> ljfh_map = fhListToMap(dto.getLjfhList());
//                 result.put(dto.getId() + "_ljfh", ljfh_map);
//             }
//             if (!StringUtils.isEmpty(dto.getJldwList())) {
//                 Map<String, String> jldw_map = fhListToMap(dto.getJldwList());
//                 result.put(dto.getId() + "_jldw", jldw_map);
//             }
//
//         }
//         return result;
//     }
//
//     private Map<String, String> fhListToMap(List<WlLbmbTzlfh> fhList) {
//         Map<String, String> fhMap = new HashMap<String, String>();
//         for (WlLbmbTzlfh fh : fhList)
//             fhMap.put(fh.getFhname(), fh.getFh_wym());
//
//         return fhMap;
//     }
//
//     private Map<String, String> tzlzListToMap(List<WlLbmbtzlqz> tzlzList) {
//         Map<String, String> tzlzMap = new HashMap<String, String>();
//         for (WlLbmbtzlqz tzlqz : tzlzList) {
//             tzlzMap.put(tzlqz.getQz(), tzlqz.getId());
//         }
//         return tzlzMap;
//     }
//
//     private void insertImportWldr(WlDr wlDr, List<WlDrTzl> tzls) {
//         this.insertWlDr(wlDr);
//         String wym = wlDr.getWym();
//         if (!StringUtils.isEmpty(tzls)) {
//             for (WlDrTzl tzl : tzls) {
//                 tzl.setWlDrId(wym);
//             }
//             // 把参数手动封装在Map中
//             Map<String, List<WlDrTzl>> map = new HashMap<String, List<WlDrTzl>>();
//             map.put("wlDrTzllist", tzls);
//             wlDrDao.batchInsertWlDrTzl(map);
//         }
//     }
//
//     /**
//      * 物料可配置业务字段
//      *
//      * @param field 字段名
//      * @param value 字段值
//      * @param wldr
//      * @author jyh
//      * @date 2017-07-08
//      */
//     private void setField(String field, String value, WlDr wldr, Map<String, String> fieldMap) {
//         if (field.equals(fieldMap.get("field1")))
//             wldr.setField1(value);
//         if (field.equals(fieldMap.get("field2")))
//             wldr.setField2(value);
//         if (field.equals(fieldMap.get("field3")))
//             wldr.setField3(value);
//         if (field.equals(fieldMap.get("field4")))
//             wldr.setField4(value);
//         if (field.equals(fieldMap.get("field5")))
//             wldr.setField5(value);
//         if (field.equals(fieldMap.get("field6")))
//             wldr.setField6(value);
//         if (field.equals(fieldMap.get("field7")))
//             wldr.setField7(value);
//         if (field.equals(fieldMap.get("field8")))
//             wldr.setField8(value);
//         if (field.equals(fieldMap.get("field9")))
//             wldr.setField9(value);
//         if (field.equals(fieldMap.get("field10")))
//             wldr.setField10(value);
//         if (field.equals(fieldMap.get("field11")))
//             wldr.setField11(value);
//         if (field.equals(fieldMap.get("field12")))
//             wldr.setField12(value);
//         if (field.equals(fieldMap.get("field13")))
//             wldr.setField13(value);
//         if (field.equals(fieldMap.get("field14")))
//             wldr.setField14(value);
//         if (field.equals(fieldMap.get("field15")))
//             wldr.setField15(value);
//         if (field.equals(fieldMap.get("field16")))
//             wldr.setField16(value);
//         if (field.equals(fieldMap.get("field17")))
//             wldr.setField17(value);
//         if (field.equals(fieldMap.get("field18")))
//             wldr.setField18(value);
//         if (field.equals(fieldMap.get("field19")))
//             wldr.setField19(value);
//         if (field.equals(fieldMap.get("field20")))
//             wldr.setField20(value);
//
//     }
//
//     @Override
//     public void wlDrExport(Map<String, Object> cond,
//                            HttpServletResponse response) {
//         // TODO Auto-generated method stub
//
//     }
//
//     @Override
//     public void wlDrApproveExport(Map<String, Object> cond,
//                                   HttpServletResponse response) {
//         // TODO Auto-generated method stub
//
//     }
//
//     @Override
//     public void wlDrMxExport(Map<String, Object> cond,
//                              HttpServletResponse response, String type) {
//         // TODO Auto-generated method stub
//
//     }
//
//     @Override
//     public String checkWhenShrEdit(String wym, String qc_no_ljfh) {
//         // TODO Auto-generated method stub
//         return null;
//     }
//
//     /**
//      * 解析导入物料特征量数据拼接成的字符串
//      *
//      * @param wlDrId     导入物料的ID
//      * @param lbbm       类别编码
//      * @param wlDrTzlStr 导入物料特征量数据拼接成的字符串
//      * @return 导入物料特征量数据对象集合
//      * @author hanxg
//      * @date 2013-8-26
//      */
//     private List<WlDrTzl> parseWlDrTzlStr(String wlDrId, String lbbm,
//                                           String wlDrTzlStr) {
//         List<WlDrTzl> list = new ArrayList<WlDrTzl>();
//         StringTokenizer stk = new StringTokenizer(wlDrTzlStr, "⊙");
//         // int i = 1;
//         while (stk.hasMoreElements()) {
//             String mxinfostr = (String) stk.nextElement();
//             StringTokenizer mxstk = new StringTokenizer(mxinfostr, "⊥");
//             String tzlmc = mxstk.nextToken().trim();
//             String wlLbmbtzlId = mxstk.nextToken().trim();
//             String xh = mxstk.nextToken().trim();
//             String qzfhId = mxstk.nextToken().trim();
//             String qzfh = mxstk.nextToken().trim();
//             String tzlzId = this.returnTzlId(mxstk.nextToken().trim());
//             String tzlz = mxstk.nextToken().trim();
//             String hzfhId = mxstk.nextToken().trim();
//             String hzfh = mxstk.nextToken().trim();
//             String jldwId = mxstk.nextToken().trim();
//             String jldw = mxstk.nextToken().trim();
//             String ljfhId = mxstk.nextToken().trim();
//             String ljfh = mxstk.nextToken().trim();
//             // String tzlz_en = mxstk.nextToken().trim();
//             WlDrTzl tzlDr = new WlDrTzl();
//             tzlDr.setWlDrId(wlDrId);
//             tzlDr.setXh(Integer.parseInt(xh));
//             tzlDr.setLbbm(lbbm);
//             tzlDr.setTzlmc(tzlmc);
//             tzlDr.setWlLbmbtzlId(wlLbmbtzlId);
//             tzlDr.setQzfhId(qzfhId);
//             tzlDr.setQzfh(qzfh);
//             tzlDr.setTzlzId(tzlzId);
//             tzlDr.setTzlz(tzlz);
//             tzlDr.setHzfhId(hzfhId);
//             tzlDr.setHzfh(hzfh);
//             if ("? undefined:undefined ?".equals(jldwId)) {
//                 tzlDr.setJldwId("");
//             } else {
//                 tzlDr.setJldwId(jldwId);
//             }
//
//             tzlDr.setJldw(jldw);
//             if ("? undefined:undefined ?".equals(ljfhId)) {
//                 tzlDr.setLjfhId("");
//             } else {
//                 tzlDr.setLjfhId(ljfhId);
//             }
//             tzlDr.setLjfh(ljfh);
//             // tzlDr.setTzlz_en(tzlz_en);
//             tzlDr.setStatus("1");
//             list.add(tzlDr);
//             // i++;
//         }
//         return list;
//     }
//
//     /**
//      * 修改前台传来的tzlid为乱码
//      *
//      * @param tzlId
//      * @return
//      */
//     private String returnTzlId(String tzlId) {
//         String tzlIdStr = "";
//         if (!StringUtils.isEmpty(tzlId)) {
//             Pattern p = Pattern.compile("^[0-9]{8}$");
//             Matcher m = p.matcher(tzlId);
//             if (m.matches()) {
//                 tzlIdStr = tzlId;
//             }
//         }
//         return tzlIdStr;
//     }
//
// 	/*void addSysLog(WlDr wlDr, String operation, String remark) {
// 		Date date = new Date();
// 		SysUser user = ShiroSessionUtils.getSessionSysUser(ConstantBean.CURRENT_SESSION_USER);
// 		SysLog sysLog = new SysLog();
// 		sysLog.setUserName(user.getUserName());
// 		sysLog.setOperationDate(date);
// 		sysLog.setOperationContent("用户【" + ShiroSessionUtils.getSessionSysUser(ConstantBean.CURRENT_SESSION_USER).getUserName()
// 				+ "】于" + DateUtils.dateToString(date, "yyyy-MM-dd HH:mm:ss") + ","+remark+"唯一码为【"+wlDr.getWym()+"】长描述为【"+wlDr.getQc2()+"】的物料");
// 		sysLogServiceImpl.insertLog(sysLog);
// 		 SysLog log = new SysLog(); log.setBusiness(Constants.WLWLDR);
// 		 log.setOperationType(Constants.OPER_TJ); log.setOperation(operation);
// 		 log.setOperationContent(remark); log.setData_id(wlDr.getWym());
// 		 log.setData_name
// 		 (StringUtils.isEmpty(wlDr.getQc2())?wlDr.getQc():wlDr.getQc2());
// 		 log.setExpand1(wlDr.getLbbm()); log.setExpand2(wlDr.getGsdm());
// 		 SysLogUtil.insertSysLog(log);
//
// 	}*/
//
//     @Override
//     public Map<String, Object> wlDrApprove(List<ShForm> forms) {
//         Map<String, Object> result = new HashMap<>();
//
//         boolean flag = true;// 默认整个审核流程通过
//
//         List<ShForm> sh_forms;
//         try {
//             sh_forms = workFlowService.approveFlowElse(forms);
//             List<ShForm> T_data = new ArrayList<ShForm>();// 审批通过且流程走完的数据
//             List<ShForm> F_data = new ArrayList<ShForm>();// 审批拒绝的数据
//             int succCount = forms.size();// 审核成功数量
//             for (int i = 0; i < sh_forms.size(); i++) {
//                 RunState runState = sh_forms.get(i).getRunState();
//                 switch (runState) {
//                     case PASSED:
//                         T_data.add(sh_forms.get(i));
//                         break;
//                     case REFUSED:
//                         F_data.add(sh_forms.get(i));
//                         break;
//                     case ERROR:
//                         succCount--;// 将审核流程运行错误的数据减掉
//                     default:
//                         break;
//                 }
//
//             }
//             // 审核流程走完并且审核通过的数据
//             if (!StringUtils.isEmpty(T_data)) {
//                 this.shenHetg(T_data);
//             }
//             // 审核拒绝的数据，更新到物料导入表
//             if (!StringUtils.isEmpty(F_data)) {
//                 this.shenHejj(F_data);
//             }
//             result.put("succCount", succCount);
//         } catch (Exception e) {
//             flag = false;
//             result.put("msg", "审核出错，请联系管理员");
//             e.printStackTrace();
//         }
//         result.put("flag", flag);
//         return result;
//     }
//
//     @Override
//     public Map<String, Object> wlDrApproveMobile(List<ShForm> forms,
//                                                  String userId) {
//         Map<String, Object> result = new HashMap<>();
//
//         boolean flag = true;// 默认整个审核流程通过
//
//         List<ShForm> sh_forms;
//         try {
//             sh_forms = workFlowService.approveFlowElseMobile(forms, userId);
//             List<ShForm> T_data = new ArrayList<ShForm>();// 审批通过且流程走完的数据
//             List<ShForm> F_data = new ArrayList<ShForm>();// 审批拒绝的数据
//             int succCount = forms.size();// 审核成功数量
//             for (int i = 0; i < sh_forms.size(); i++) {
//                 RunState runState = sh_forms.get(i).getRunState();
//                 switch (runState) {
//                     case PASSED:
//                         T_data.add(sh_forms.get(i));
//                         break;
//                     case REFUSED:
//                         F_data.add(sh_forms.get(i));
//                         break;
//                     case ERROR:
//                         succCount--;// 将审核流程运行错误的数据减掉
//                     default:
//                         break;
//                 }
//
//             }
//             // 审核流程走完并且审核通过的数据
//             if (!StringUtils.isEmpty(T_data)) {
//                 this.shenHetg(T_data);
//             }
//             // 审核拒绝的数据，更新到物料导入表
//             if (!StringUtils.isEmpty(F_data)) {
//                 this.shenHejj(F_data);
//             }
//             result.put("succCount", succCount);
//         } catch (Exception e) {
//             flag = false;
//             result.put("msg", "审核出错，请联系管理员");
//             e.printStackTrace();
//         }
//         result.put("flag", flag);
//         return result;
//     }
//
//     // 审核通过处理
//     public void shenHetg(List<ShForm> T_data) {
//         List<ShForm> a_form = new ArrayList<ShForm>();// 新增物料
//         List<ShForm> u_form = new ArrayList<ShForm>();// 变更物料
//         List<ShForm> ac_form = new ArrayList<ShForm>();// 解冻数据
//         List<ShForm> fr_form = new ArrayList<ShForm>();// 冻结数据
//
//         for (int k = 0; k < T_data.size(); k++) {
//             ShForm shForm = T_data.get(k);
//             if ("submit".equals(shForm.getOperType()))
//                 a_form.add(shForm);
//             else if ("update".equals(shForm.getOperType()))
//                 u_form.add(shForm);
//             else if ("active".equals(shForm.getOperType()))
//                 ac_form.add(shForm);
//             else if ("freeze".equals(shForm.getOperType()))
//                 fr_form.add(shForm);
//         }
//         // 生成物料编码
//         if (a_form.size() > 0) {
//             SysUser user = ShiroSessionUtils.getSessionSysUser(ConstantBean.CURRENT_SESSION_USER);
//             Map<String, String> cond = new HashMap<String, String>();
//             for (int a = 0; a < a_form.size(); a++) {
//                 cond.put("wym", a_form.get(a).getDataId());
//                 cond.put("state", "4");
//                 cond.put("zxshyj", "同意");
//                 if (user == null) {//万达工作流和OA集成，审核通过之后调用MDM服务端进行后续业务操作，所以获取当前用户为空
//                     String systemCode = sysParameterService.getSysParamValue("systemCode", "MDM");// 获取系统参数systemCode，如果返回值为空则默认返回值为"MDM"
//                     if ("WanDa".equals(systemCode)) {
//                         cond.put("sprbm", "");
//                         cond.put("sprmc", "OA审核人");
//                     } else {
//                         cond.put("sprbm", "");
//                         cond.put("sprmc", "");
//                     }
//                 } else {
//                     cond.put("sprbm", user.getUserId().toString());
//                     cond.put("sprmc", user.getUserName());
//                 }
//                 // 最后节点审批通过，生成物料代码
//                 this.createWl(cond);// 在存储过程中更新物料表
//             }
//         }
//
//         // 变更
//         if (u_form.size() > 0) {
//             String actiontype = "2";// 操作类型 1:新增，2:修改，3:启用，4:停用
//             this.update(u_form, actiontype);
//         }
//         // 解冻
//         if (ac_form.size() > 0) {
//             String actiontype = "3";// 操作类型 1:新增，2:修改，3:启用，4:停用
//             this.update(ac_form, actiontype);
//         }
//         // 冻结
//         if (fr_form.size() > 0) {
//             String actiontype = "4";// 操作类型 1:新增，2:修改，3:启用，4:停用
//             this.update(fr_form, actiontype);
//         }
//
//     }
//
//     /**
//      * @param sh_form    审核数据
//      * @param actiontype //操作类型 1:新增，2:修改，3:启用，4:停用
//      */
//     private void update(List<ShForm> sh_form, String actiontype) {
//         List<String> idList = new ArrayList<String>();
//         for (ShForm sh : sh_form)
//             idList.add(sh.getDataId());
//
//         Map<String, Object> cond = new HashMap<>();
//         cond.put("state", 4);
//         cond.put("idList", idList);
//         cond.put("ope", 1);
//         wlwlUpdateService.updateWlwlUpdate(cond);// 更新物料变更表
//         if ("2".equals(actiontype)) {
//             //2018-01-30 物料长描述变更审核通过后续处理 (调用存储过程 更新物料主表等)
//             //变更分2种情况 1.物料数据修改  2.物料长描述变更
//             //只有物料长描述变更需要走存储过程
//             Map<String, Object> upd_cond = new HashMap<>();
//             upd_cond.put("idList", idList);
//             upd_cond.put("state", 4);
//             List<WlwlUpdate> upd_lst = wlwlUpdateDao.bianGengWlwlUpdate(upd_cond);
//             List<String> wlUpd_lst = new ArrayList<String>();//物料变更list
//             List<String> wlQcUpd_lst = new ArrayList<String>();//物料长描述变更list
//             for (int i = 0; i < upd_lst.size(); i++) {
//                 //物料变更表Operationtype字段值 0表示物料修改，3表示物料长描述变更
//                 if ("3".equals(upd_lst.get(i).getOperationtype()))
//                     wlQcUpd_lst.add(upd_lst.get(i).getId());
//                 else if ("0".equals(upd_lst.get(i).getOperationtype()))
//                     wlUpd_lst.add(upd_lst.get(i).getId());
//             }
//             //物料长描述变更审核通过后续处理
//             if (!StringUtils.isEmpty(wlQcUpd_lst)) {
//                 Map<String, Object> map = new HashMap<>();
//                 for (int j = 0; j < wlQcUpd_lst.size(); j++) {
//                     map.put("id", wlQcUpd_lst.get(j));
//                     wlwlUpdateService.wlQcUpdatePass(map);
//                 }
//             }
//             //物料变更审核通过后续处理
//             if (!StringUtils.isEmpty(wlUpd_lst))
//                 wlwlUpdateService.updateWlwlByUpdate(cond);// 更新物料表
//         } else
//             wlwlUpdateService.updateWlwlStatusByUpdate(cond);// 冻结/解冻物料表
//
//
//         wlwlService.insertWlwlDis(
//                 wlwlUpdateService.getWlwlUpdateWlbmByIds(cond), actiontype);// 向分发表添加数据
//     }
//
//     // 审核拒绝处理
//     public void shenHejj(List<ShForm> F_data) {
//         List<ShForm> a_form = new ArrayList<ShForm>();// 新增物料
//         List<ShForm> u_form = new ArrayList<ShForm>();// 变更物料
//         List<ShForm> ac_form = new ArrayList<ShForm>();// 解冻数据
//         List<ShForm> fr_form = new ArrayList<ShForm>();// 冻结数据
//
//         List<ShForm> shLst = new ArrayList<ShForm>();// 待更新物料变更表数据
//
//         for (int k = 0; k < F_data.size(); k++) {
//             ShForm shForm = F_data.get(k);
//             if ("submit".equals(shForm.getOperType()))
//                 a_form.add(shForm);
//             else {
//                 shLst.add(shForm);
//                 if ("update".equals(shForm.getOperType()))
//                     u_form.add(shForm);
//                 else if ("active".equals(shForm.getOperType()))
//                     ac_form.add(shForm);
//                 else if ("freeze".equals(shForm.getOperType()))
//                     fr_form.add(shForm);
//             }
//         }
//
//         // 更新物料导入表
//         if (a_form.size() > 0) {
//             Map<String, Object> F_cond = new HashMap<>();
//             for (int j = 0; j < F_data.size(); j++) {
//                 ShForm shForm = F_data.get(j);
//                 F_cond.put("wym", shForm.getDataId());
//                 F_cond.put("state", "6");
//                 F_cond.put("zxshyj", shForm.getOpinion());
//                 F_cond.put("cwlx", shForm.getCwlx());
//                 this.updateWlDr(F_cond);// 更新物料表
//             }
//         }
//         if (shLst.size() > 0) {
//             // 更新物料变更表
//             List<String> idList = new ArrayList<String>();
//             for (ShForm form : shLst)
//                 idList.add(form.getDataId());
//             Map<String, Object> upd_cond = new HashMap<>();
//             upd_cond.put("idList", idList);
//             upd_cond.put("state", "6");
//             wlwlUpdateService.updateWlwlUpdate(upd_cond);// 更新物料变更表
//             /*
//              * //变更 if(u_form.size()>0){
//              *
//              * } //解冻 if(ac_form.size()>0){
//              *
//              * } //冻结 if(fr_form.size()>0){
//              *
//              * }
//              */
//         }
//
//     }
//
// 	/*String getCellVal(Row row, int columnIndex) {
// 		Cell cell = row.getCell(columnIndex);
// 		if (cell == null) {
// 			return "";
// 		} else {
// 			String str = "";
// 			switch (cell.getCellType()) {
// 			case Cell.CELL_TYPE_FORMULA:
// 				str = cell.getRichStringCellValue().getString();
// 				break;
// 			default:
// 				cell.setCellType(Cell.CELL_TYPE_STRING);
// 				str = cell.getStringCellValue();
// 			}
// 			return str;
// 		}
// 	}*/
//
//     String getCellVal(Row row, int columnIndex) {
//         Cell cell = row.getCell(columnIndex);
//         if (cell == null) {
//             return "";
//         } else {
//             String str = "";
//             switch (cell.getCellType()) {
//                 case Cell.CELL_TYPE_FORMULA:
//                     str = cell.getRichStringCellValue().getString();
//                     break;
//                 case Cell.CELL_TYPE_NUMERIC:
//                     short format = cell.getCellStyle().getDataFormat();
//                     if (format == 14 || format == 31 || format == 57 || format == 58) {   //excel中的时间格式
//                         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//                         double value = cell.getNumericCellValue();
//                         Date date = DateUtil.getJavaDate(value);
//                         str = sdf.format(date);
//                     }
//                     // 判断当前的cell是否为Date
//                     else if (HSSFDateUtil.isCellDateFormatted(cell)) {  //先注释日期类型的转换，在实际测试中发现HSSFDateUtil.isCellDateFormatted(cell)只识别2014/02/02这种格式。
//                         // 如果是Date类型则，取得该Cell的Date值           // 对2014-02-02格式识别不出是日期格式
//                         Date date = cell.getDateCellValue();
//                         DateFormat formater = new SimpleDateFormat("yyyy-MM-dd");
//                         str = formater.format(date);
//                     } else { // 如果是纯数字
//                         // 取得当前Cell的数值
//                         str = NumberToTextConverter.toText(cell.getNumericCellValue());
//
//                     }
//                     break;
//                 default:
//                     cell.setCellType(Cell.CELL_TYPE_STRING);
//                     str = cell.getStringCellValue();
//             }
//             return str;
//         }
//     }
//
//     /**
//      * 判断字符串长度
//      * edit by wangyk at 180329:和李剑孟昕确认过，物料计算长短描述 的长度1个汉字1个长度，
//      * 跟数据库存储无关，直接使用length方法即可
//      *
//      * @param s
//      * @return
//      */
//     public int getStringLength(String s) {
//         return s.length();
// 		/*boolean flag;
// 		int sleng = 0;
// 		System.out.println(s.length());
// 		for (int x = 0; x < s.length(); x++) {
// 			flag = isChinese(String.valueOf(s.charAt(x)));
// 			if (flag) {
// 				sleng += 3;
// 			} else {
// 				sleng++;
// 			}
// 		}
// 		return sleng;*/
//     }
//
//     /**
//      * 判断是否是汉字
//      *
//      * @param str
//      * @return
//      */
//     public static boolean isChinese(String str) {
//         String regEx = "[\u4e00-\u9fa5]";
//         Pattern pat = Pattern.compile(regEx);
//         Matcher matcher = pat.matcher(str);
//         boolean flg = false;
//         if (matcher.find())
//             flg = true;
//
//         return flg;
//     }
//
//     @Override
//     public List<WlDr> checkByCur(String wyms_x) {
//         Map map = new HashMap();
//         map.put("wyms", wyms_x);
//         return wlDrDao.checkByCur(map);
//
//     }
//
//     public static String subStringByByte(String str, int byteNum) throws Exception {
//         if (!StringUtils.isEmpty(str)) {
//             int a = 0;
//             String temp = "";
//             for (int i = 0; i < str.length(); i++) {
//                 if (WlDrServiceImpl.isChinese(String.valueOf(str.charAt(i)))) {
//                     a += 3;
//                 } else {
//                     a++;
//                 }
//                 if (a > byteNum) {
//                     return temp;
//                 }
//                 temp += str.charAt(i);
//             }
//             return str;
//         } else {
//             System.out.println("错误!!!短描述为空：");
//             throw new Exception();
//         }
//
//     }
//
//     @Override
//     public int getCountByDelLbJldw(Map<String, Object> map) {
//         return wlDrDao.getCountByDelLbJldw(map);
//     }
//
//     @Override
//     public int getCountByLbUpdAndDel(Map<String, Object> map) {
//         return wlDrDao.getCountByLbUpdAndDel(map);
//     }
//
//     @Override
//     public WlDr getApproveByWym(String wym) {
//         return wlDrDao.getApproveByWym(wym);
//     }
//
//     @Override
//     public void exportWlDr(List<WlDr> list, List<WlwlField> field, HttpServletResponse response) {
//         try {
//             String tablename = "物料代码申请历史";
//             // 声明一个工作薄
//             XSSFWorkbook workbook = new XSSFWorkbook();
//             XSSFSheet sheet = workbook.createSheet("物料代码申请历史");
//             XSSFRow row = sheet.createRow(0);
//             XSSFCell cell = null;
//             CellStyle style = ExcelUtil.createCellTextStyle(workbook);
//             cell = row.createCell(0);
//             sheet.setDefaultColumnStyle(0, style);
//             cell.setCellValue("唯一码");
//             cell = row.createCell(1);
//             sheet.setDefaultColumnStyle(1, style);
//             cell.setCellValue("状态");
//             cell = row.createCell(2);
//             sheet.setDefaultColumnStyle(2, style);
//             cell.setCellValue("错误类型");
//             cell = row.createCell(3);
//             sheet.setDefaultColumnStyle(3, style);
//             cell.setCellValue("提示信息");
//             cell = row.createCell(4);
//             sheet.setDefaultColumnStyle(4, style);
//             cell.setCellValue("长描述(生成)");
//             cell = row.createCell(5);
//             sheet.setDefaultColumnStyle(5, style);
//             cell.setCellValue("短描述(生成)");
//             cell = row.createCell(6);
//             sheet.setDefaultColumnStyle(6, style);
//             cell.setCellValue("物料代码");
//             cell = row.createCell(7);
//             sheet.setDefaultColumnStyle(7, style);
//             cell.setCellValue("类别代码");
//             cell = row.createCell(8);
//             sheet.setDefaultColumnStyle(8, style);
//             cell.setCellValue("类别名称");
//             cell = row.createCell(9);
//             sheet.setDefaultColumnStyle(9, style);
//             cell.setCellValue("长描述(导入)");
//             cell = row.createCell(10);
//             sheet.setDefaultColumnStyle(10, style);
//             cell.setCellValue("短描述(导入)");
//             cell = row.createCell(11);
//             sheet.setDefaultColumnStyle(11, style);
//             cell.setCellValue("计量单位");
//             cell = row.createCell(12);
//             sheet.setDefaultColumnStyle(12, style);
//             cell.setCellValue("创建时间");
//             cell = row.createCell(13);
//             sheet.setDefaultColumnStyle(13, style);
//             cell.setCellValue("提交时间");
//             cell = row.createCell(14);
//             sheet.setDefaultColumnStyle(14, style);
//             cell.setCellValue("提交人");
//             cell = row.createCell(15);
//             sheet.setDefaultColumnStyle(15, style);
//             cell.setCellValue("提交次数");
//             cell = row.createCell(16);
//             sheet.setDefaultColumnStyle(16, style);
//             cell.setCellValue("备注");
//             if (field.size() > 0 && field != null) {
//                 for (int i = 0; i < field.size(); i++) {
//                     cell = row.createCell(17 + i);
//                     sheet.setDefaultColumnStyle(17 + i, style);
//                     cell.setCellValue("" + field.get(i).getFieldName() + "");
//                 }
//             }
//
//             for (int i = 0; i < list.size(); i++) {
//                 WlDr getWlLb = list.get(i);
//                 row = sheet.createRow(i + 1);
//                 cell = row.createCell(0);
//                 cell.setCellValue(getWlLb.getWym());
//                 cell = row.createCell(1);
//                 String zhuangtai = "";
//                 if ("1".equals(getWlLb.getState())) {
//                     zhuangtai = "有错误";
//                 } else if ("0".equals(getWlLb.getState())) {
//                     zhuangtai = "可提交";
//                 } else if ("3".equals(getWlLb.getState())) {
//                     zhuangtai = "可提交";
//                 } else if ("4".equals(getWlLb.getState())) {
//                     zhuangtai = "审核通过";
//                 } else if ("5".equals(getWlLb.getState())) {
//                     zhuangtai = "待审核";
//                 } else if ("6".equals(getWlLb.getState())) {
//                     zhuangtai = "被驳回";
//                 } else if ("10".equals(getWlLb.getState())) {
//                     zhuangtai = "已删除";
//                 }
//                 cell.setCellValue(zhuangtai);
//                 cell = row.createCell(2);
//                 cell.setCellValue(getWlLb.getCwlx());
//                 cell = row.createCell(3);
//                 cell.setCellValue(getWlLb.getErrtext());
//                 cell = row.createCell(4);
//                 cell.setCellValue(getWlLb.getQc2());
//                 cell = row.createCell(5);
//                 cell.setCellValue(getWlLb.getJc2());
//                 cell = row.createCell(6);
//                 cell.setCellValue(getWlLb.getWlbm());
//                 cell = row.createCell(7);
//                 cell.setCellValue(getWlLb.getLbbm());
//                 cell = row.createCell(8);
//                 cell.setCellValue(getWlLb.getLbmc());
//                 cell = row.createCell(9);
//                 cell.setCellValue(getWlLb.getQc());
//                 cell = row.createCell(10);
//                 cell.setCellValue(getWlLb.getJc());
//                 cell = row.createCell(11);
//                 cell.setCellValue(getWlLb.getJldw());
//                 cell = row.createCell(12);
//                 cell.setCellValue(getWlLb.getCreateTime());
//                 cell = row.createCell(13);
//                 cell.setCellValue(getWlLb.getSubmitTime());
//                 cell = row.createCell(14);
//                 cell.setCellValue(getWlLb.getCreatorName());
//                 cell = row.createCell(15);
//                 cell.setCellValue(getWlLb.getSubmitcount());
//                 cell = row.createCell(16);
//                 cell.setCellValue(getWlLb.getRemark());
//                 if (field.size() > 0 && field != null) {
//                     Class<?> cls = getWlLb.getClass();
//                     Method[] methods = cls.getDeclaredMethods();
//                     Field[] fields = cls.getDeclaredFields();
//                     //通过反射遍历属性字段和值
//                     for (int j = 0; j < field.size(); j++) {
//                         cell = row.createCell(17 + j);
//                         String fieldGetName = StringUtil.parGetName(field.get(j).getField());
//                         Method fieldGetMet = cls.getMethod(fieldGetName, new Class[]{});
//                         Object fieldVal = fieldGetMet.invoke(getWlLb, new Object[]{});
//                         String result = String.valueOf(fieldVal).equals("null") ? "" : String.valueOf(fieldVal);
//                         cell.setCellValue(result);
//                     }
//                 }
//             }
//             ExcelExportUtil.outExportExcel(tablename, workbook, response);
//         } catch (Exception e) {
//             e.printStackTrace();
//         }
//
//     }
//
//     @SuppressWarnings({"unchecked", "rawtypes"})
//     @Override
//     public PageInfo queryWlDr2(Map<String, Object> cond) {
//         PageInfo pageInfo = null;
//         try {
//             /*
//              * 参数
//              *
//              * @params参数详情 pageNum 总页数
//              *
//              * @params参数详情 length 每页显示条数
//              *
//              * @params参数详情 start 起始条数
//              *
//              * @params参数详情 draw 请求次数
//              *
//              * @return 分页条件下的
//              */
//             Object pNo = cond.get("pageNum");
//             int pageNum, pageSize;
//             // export
//             if (pNo != null && !"NaN".equals(pNo)) {
//                 pageNum = Integer.parseInt(pNo.toString());// 页码
//             } else {
//                 pageNum = 1;
//             }
//             // pageSize=0时不分页
//             pageSize = Integer.parseInt(cond.get("limit").toString());// 模型定义页面要显示数据条数
//             // 例如
//             // 10,20,50,100
//             PageHelper.startPage(pageNum, pageSize);// 开始分页标志（当前页，显示条数）
//
//             List<WlDr> wlDr_lst = wlDrDao.queryWlDr(cond);
//             pageInfo = new PageInfo(wlDr_lst);
//         } catch (Exception e) {
//             e.printStackTrace();
//         }
//         return pageInfo;
//     }
//
//     @Override
//     public int checkCanDelete(String wyms) {
//         return wlDrDao.checkCanDelete(wyms);
//     }
//
//
// }
